package cn.cloud9.api;

import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Locale;

public class API01String {

    public static void main(String[] args) {

        String simple = "java, aaa, bbb, ccc";
        simple = simple.toLowerCase();
        char a = 'a';
        int count = 0;
        for (int i = 0; i < simple.length(); i++) {
            if (simple.charAt(i) == a) ++ count;
        }
        System.out.println(count);
    }
    /**
     * 构造器常见用法:
     */
    private static void howUseConstructor() {
        // 直接声明字面值使用
        String usage1 = "String";
        System.out.println("usage1 -> " + usage1);

        // 空参构造
        String usage2 = new String();
        System.out.println("usage2 -> " + usage2);

        // 套字符构造
        String usage3 = new String(usage1);
        System.out.println("usage3 -> " + usage3);

        // 字符数组构造
        char[] chars = {'j', 'a', 'v', 'a'};
        String usage4 = new String(chars);
        System.out.println("usage4 -> " + usage4);

        // 字节数组构造
        byte[] bytes = {88, 87, 85, 99};
        String usage5 = new String(bytes, StandardCharsets.UTF_8);
        System.out.println("usage5 -> " + usage5);
    }

    /**
     * 常用的API
     *
     */
    private static void commonApi() {
        String demo = "Java, MySQL, SpringBoot, Redis, SpringCloud, JavaScript, ElasticSearch, Tomcat, Jdbc";

        // 获取字符串的字符长度
        int length = demo.length();

        // 判断是否是空串？
        System.out.println("".isEmpty()); // true
        System.out.println(demo.isEmpty()); // false

        // 获取指定下标上的字符, 调用这个方法尽量使用length - 1设置下标值，控制越界的风险
        char targetChar = demo.charAt( length - 3);
        System.out.println("[" + targetChar + "]");

        // 获取指定下标上的字符ASCII编码值,
        int targetCharCode = demo.codePointAt(length - 3);
        System.out.println("[" + targetCharCode + "]");

        // 获取前一个字符的ASCII编码值
        int targetCharCode2 = demo.codePointBefore(length - 3);
        System.out.println("[" + targetCharCode2 + "] -> " + demo.codePointAt(length - 4));


        /**
         * 取一部分做char数组
         * srcBegin -- 字符串中要复制的第一个字符的索引。
         * srcEnd -- 字符串中要复制的最后一个字符之后的索引。
         * dst -- 目标数组。
         * dstBegin -- 目标数组中的起始偏移量。
         *  demo.getChars(0, cuts.length, cuts, 0);
         */
        char[] cuts = new char[15];
        demo.getChars(0, cuts.length, cuts, 0);
        System.out.println(Arrays.toString(cuts));

        /**
         * 字符串转字节数组
         * 建议使用这种参数转换，指定字符编码UTF-8
         * "ABC" 一般无影响，如果有汉字“你好Java”这样的就要注意乱码了
         * demo.getBytes(StandardCharsets.UTF_8)
         */
        byte[] bytes = demo.getBytes(StandardCharsets.UTF_8);
        System.out.println(Arrays.toString(bytes));

        /**
         * 字符比较一律使用 string.equals(targetObject)
         */
        System.out.println("abc".equals(new String("abc")));
        System.out.println("abc" == new String("abc"));

        /**
         * 给buffer或者字符相关的专门提供了内容比较
         * string.contentEquals(param)
         */
        System.out.println("contentEquals -> " + ("abc".contentEquals(new StringBuffer("abc"))));
        System.out.println("contentEquals -> " + ("abc".contentEquals(new String("abc"))));

        /**
         * 忽略字母大小进行比较
         * string.equalsIgnoreCase(param)
         */
        System.out.println("java -> JAVA or JaVA ? " + ( "java".equalsIgnoreCase("JaVA") ));

        /**
         * 字符大小比较
         * -1 表示 调用字符串 < 参数字符串
         * 1 表示 调用字符串 > 参数字符串
         * 0 表示 调用字符串 = 参数字符串
         * string.compareTo("B")
         * string.compareToIgnoreCase("B")
         */
        System.out.println("A.compareTo(B) -> " + ("A".compareTo("B")));
        System.out.println("B.compareTo(A) -> " + ("B".compareTo("A")));
        System.out.println("A.compareTo(A) -> " + ("A".compareTo("A")));

        /**
         * 忽视字母大小写判断
         */
        System.out.println("A.compareTo(a) -> " + ("A".compareToIgnoreCase("a")));

        /**
         * 范围匹配，即在指定的一个片段如果一样，则为true
         * 可以开启忽略字母大小写
         */
        String Str1 = "www.runoob.com";
        String Str2 = "runoob";
        String Str3 = "RUNOOB";

        System.out.println("www.runoob.com [runoob] ? " +  Str1.regionMatches(4, Str2, 0, 5));
        System.out.println("www.runoob.com [RUNOOB] ? " +  Str1.regionMatches(4, Str3, 0, 5));
        System.out.println("www.runoob.com [RUNOOB] (ignoreCase) ? " +  Str1.regionMatches(true, 4, Str3, 0, 5));

        /**
         * 是否为...的前缀?
         * 可选参数2 指定从哪开始判断
         * string.startsWith("www")
         * string.startsWith("runoob", 4)
         */
        System.out.print("返回值 :" );
        System.out.println(Str1.startsWith("www") );

        System.out.print("返回值 :" );
        System.out.println(Str1.startsWith("runoob") );

        System.out.print("返回值 :" );
        System.out.println(Str1.startsWith("runoob", 4) );

        /**
         * 以...为结尾？
         * string.endsWith(".jpeg")
         */
        String file = "pic.jpeg";
        System.out.println("pic.jpeg suffix[.jpeg] ? " + file.endsWith(".jpeg"));

        /**
         * 获取目标字符串在此字符串中的首个下标
         * 如果未找到则返回 -1
         * string.indexOf(".net")
         */
        System.out.println("findPos -> "  + ( "java, mysql".indexOf(".net")));
        System.out.println("findPos -> "  + ( "java, oracle, mysql, oracle,".indexOf("oracle")));

        /**
         * 或者设定从选定的下标开始向后寻找
         * string.indexOf("oracle", 7)
         */
        System.out.println("findPos -> "  + ( "java, oracle, mysql, oracle,".indexOf("oracle", 7)));

        /**
         *
         * 从字符串后面开始计算 目标字符的下标
         * string.lastIndexOf('c') 字符入参
         * string.lastIndexOf("oracle") 字符串入参
         *
         * 也可以指定起始位置
         * string.lastIndexOf('c', 3) 字符入参
         * string.lastIndexOf("oracle", 8) 字符串入参
         */
        System.out.println("lastPos -> "  + ( "java, oracle, mysql, oracle".lastIndexOf('c')));
        System.out.println("lastPos -> "  + ( "java, oracle, mysql, oracle".lastIndexOf("oracle")));
        System.out.println("lastPos -> "  + ( "java, oracle, mysql, oracle".lastIndexOf('c', 20)));
        System.out.println("lastPos -> "  + ( "java, oracle, mysql, oracle".lastIndexOf("oracle", 8)));

        /**
         * 从下标位置开始截取到最后
         * string.substring(下标值)
         *
         * 或者决定开始下标和结束下标
         *
         */
        final String DEMO = "java, oracle, mysql";
        System.out.println(DEMO.substring(DEMO.length() - 5));
        System.out.println(DEMO.substring(DEMO.length() - 13, DEMO.length() - 7));

        /**
         * 字符拼接
         * string.concat("ssss")
         * 其实就直接使用 + 拼接就行了
         */
        System.out.println("abc".concat("123"));

        /**
         *
         * 字符替换
         * string.replace("目标字符", "替换字符")
         */
        System.out.println(DEMO.replace(",", "|"));

        /**
         * 是否匹配正则表达式
         * string.matches("REGEXP")
         */
        System.out.println("123344".matches("^[0-9]*$"));

        /**
         * 是否包含参数字符
         * string.contains('目标字符')
         */
        System.out.println(DEMO.contains("java"));

        /**
         * 只替换第一个
         * string.replaceFirst("目标字符", "替换字符")
         */
        System.out.println(DEMO.replaceFirst(",", "|"));

        /**
         * 使用正则进行全文替换
         * string.replaceAll("(.*)oracle(.*)", "postgreSQL")
         */
        final String DEMO2 = "java, oracle, mysql";
        System.out.println(DEMO2.replaceAll("(.*)oracle(.*)", "postgreSQL"));

        /**
         *
         * 按什么符号进行分隔
         * string.split(",") 参数是正则表达式,也可以单字符判断
         * string.split(",", 3) 然后是分割分数限制,即指定个数,即使后面符合切分规则,也不再进行,直接视为整体
         */
        final String DEMO3 = "1,2,3,4,5";

        String[] strings = DEMO3.split(",");
        System.out.println(Arrays.toString(strings));

        strings  = DEMO3.split(",", 3);
        System.out.println(Arrays.toString(strings));

        /**
         * 按指定顺序进行拼接
         * string.split("拼接符号", "字符串1", "字符串2", "字符串3", ...);
         */
        String[] arrs = {"A", "B", "C"};
        System.out.println("".join(",", arrs));


        /**
         * 统一大小写转换
         * string.toUpperCase()
         * string.toLowerCase()
         */
        System.out.println("abc".toUpperCase());
        System.out.println("ABC".toLowerCase());

        /**
         * 去除左右多余的空格
         * string.trim()
         */
        System.out.println(" 1 ".trim());

        /**
         * https://blog.csdn.net/weichi7549/article/details/107731550
         * 当常量池中不存在"abc"这个字符串的引用，将这个对象的引用加入常量池，返回这个对象的引用。
         * 当常量池中存在"abc"这个字符串的引用，返回这个"abc"常量的对象的引用；
         */
        String str1 = new StringBuilder("计算机").append("软件").toString();
        String str2 = str1.intern();
        String str3 = new StringBuilder("ja").append("va").toString();
        String str4 = str3.intern();
        System.out.println(str1==str2);
        System.out.println(str3==str4);

        /**
         * 基本数据类型转换成String
         * String.valueOf(基本数据类型参数)
         */
        System.out.println(String.valueOf(1000d));

    }
}

